/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package logic;

import analisador.classesDeIdentificadores.Simbolo;
import analisador.classesDeIdentificadores.SimboloConstante;
import analisador.classesDeIdentificadores.SimboloVariavelVetor;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 *
 * @author Augusto
 */
public class SymbolTable {
    List<Simbolo> ts = new LinkedList<Simbolo>();
    
    private int nivelAtual;
 
    //atributos auxiliares para constantes
    private String tipoConstante;
    private double valorConstanteReal;
    private boolean valorConstanteBoolean;
    private String valorConstanteLiteral;
    private int valorConstanteInteiro;
    
    //atributos auxiliares para Lista
    private String primeiroIdLista;
    private String ultimoIdLista;
    private String contextoLID;
    private String contextoEXPR;
    private String tipoAtual;
    
    //método de passagem de parâmetro ( ref ou val )
    private String mpp;
    
    //número de par formais
    private int npf;
    
    //número de parametros atuais
    private int npa;
    
    //variáveis auxiliares para declaração de vetor
    private String tipoLimiteInferiorDim1;
    private String tipoLimiteSuperiorDim1;
    
    private String tipoLimiteInferiorDim2;
    private String tipoLimiteSuperiorDim2;
    
    private int valorInteiroInferiorDim1;
    private int valorInteiroSuperiorDim1;
    
    private int valorInteiroInferiorDim2;
    private int valorInteiroSuperiorDim2;
    
    private String valorCaracterInferiorDim1;
    private String valorCaracterSuperiorDim1;
    
    private String valorCaracterInferiorDim2;
    private String valorCaracterSuperiorDim2;
    
    private int numeroDimensoesVetor;
    
    //valores para expressão
    private String tipoLadoEsquerdo;
    
    private String tipoElementosVetor;
    
    //#29
    private String idComando;
    
    private String opNega;
    private String opUnario;
    private String tipoExp;
    private String tipoFator;
    private String tipoVar;
    private String tipoExpSimples;
    private String tipoTermo;
    
    private String tipoVarIndexada;

    private int numeroDeIndices;
    
    private String tipoIndiceDimensao1;
    private String tipoIndiceDimensao2;
    public SymbolTable()
    {
         this.ts = new LinkedList<Simbolo>();
         this.nivelAtual = 0;
         this.npf = 0;
         this.npa = 0;
         this.numeroDeIndices = 0;
          //atributos auxiliares para constantes
         this.tipoConstante = null;
         this.contextoEXPR = null;
         
         //this.valorConstanteReal = 0.0;
         //this.valorConstanteBoolean = false;
         this.valorConstanteLiteral = null;
         //this.valorConstanteInteiro = 0;
    
         //atributos auxiliares para Lista
         this.primeiroIdLista = null;
         this.ultimoIdLista = null;
         this.contextoLID = null;
    
         this.tipoAtual = null;
    
         //método de passagem de parâmetro ( ref ou val )
         this.mpp = null;
         
         this.tipoLimiteInferiorDim1 = "";
         this.tipoLimiteSuperiorDim1 = "";

         this.tipoLimiteInferiorDim2 = "";
         this.tipoLimiteSuperiorDim2 = "";
         
         this.numeroDimensoesVetor = 0;
         
         //valores para expressão
         this.tipoLadoEsquerdo = null;
    }

    public String getTipoIndiceDimensao1() {
        return tipoIndiceDimensao1;
    }

    public void setTipoIndiceDimensao1(String tipoIndiceDimensao1) {
        this.tipoIndiceDimensao1 = tipoIndiceDimensao1;
    }

    public String getTipoIndiceDimensao2() {
        return tipoIndiceDimensao2;
    }

    public void setTipoIndiceDimensao2(String tipoIndiceDimensao2) {
        this.tipoIndiceDimensao2 = tipoIndiceDimensao2;
    }

    public int getNumeroDeIndices() {
        return numeroDeIndices;
    }

    public void setNumeroDeIndices(int numeroDeIndices) {
        this.numeroDeIndices = numeroDeIndices;
    }

    public int getNpa() {
        return npa;
    }

    public void setNpa(int npa) {
        this.npa = npa;
    }

    public String getTipoVarIndexada() {
        return tipoVarIndexada;
    }

    public void setTipoVarIndexada(String tipoVarIndexada) {
        this.tipoVarIndexada = tipoVarIndexada;
    }
    
    public String getTipoExpSimples() {
        return tipoExpSimples;
    }

    public void setTipoExpSimples(String tipoExpSimples) {
        this.tipoExpSimples = tipoExpSimples;
    }

    public String getTipoTermo() {
        return tipoTermo;
    }

    public void setTipoTermo(String tipoTermo) {
        this.tipoTermo = tipoTermo;
    }
    
    public String getTipoVar() {
        return tipoVar;
    }

    public void setTipoVar(String tipoVar) {
        this.tipoVar = tipoVar;
    }
    
    public String getTipoExp() {
        return tipoExp;
    }

    public void setTipoExp(String tipoExp) {
        System.out.println("@@@@@@@@@@ setTipoExp: " + tipoExp);
        this.tipoExp = tipoExp;
    }

    public String getTipoFator() {
        return tipoFator;
    }

    public void setTipoFator(String tipoFator) {
        this.tipoFator = tipoFator;
    }
    
    public String getOpNega() {
        return opNega;
    }

    public void setOpNega(String opNega) {
        this.opNega = opNega;
    }

    public String getOpUnario() {
        return opUnario;
    }

    public void setOpUnario(String opUnario) {
        this.opUnario = opUnario;
    }
    
    public String getIdComando() {
        return idComando;
    }

    public void setIdComando(String idComando)
    {
        System.out.println("<<<<<<<<<<<<<<<<<< SETANDO ID COMANDO: " + idComando + " >>>>>>>>>>>>>>>>>>>");
        this.idComando = idComando;
    }

    public String getTipoLadoEsquerdo() {
        return tipoLadoEsquerdo;
    }

    public void setTipoLadoEsquerdo(String tipoLadoEsquerdo)
    {
        System.out.println( "<<<<<<<<<<<<<<<<< setTipoLadoEsquerdo: " + tipoLadoEsquerdo + " >>>>>>>>>>>>>" );
        this.tipoLadoEsquerdo = tipoLadoEsquerdo;
    }
    
    public String getTipoElementosVetor() {
        return tipoElementosVetor;
    }

    public void setTipoElementosVetor(String tipoElementosVetor) {
        this.tipoElementosVetor = tipoElementosVetor;
    }
    
    public int getNumeroDimensoesVetor() {
        return numeroDimensoesVetor;
    }

    public void setNumeroDimensoesVetor(int numeroDimensoesVetor) {
        this.numeroDimensoesVetor = numeroDimensoesVetor;
    }

    public String getContextoEXPR() {
        return contextoEXPR;
    }

    public void setContextoEXPR(String contextoEXPR) {
        this.contextoEXPR = contextoEXPR;
    }
    
    public String getTipoLimiteInferiorDim1() {
        return tipoLimiteInferiorDim1;
    }

    public void setTipoLimiteInferiorDim1(String tipoLimiteInferiorDim1) {
        System.out.println("$%¨&$%¨&$%&$%& SETANDO TIPO LIMITE INFERIOR DIM 1 PARA: " + tipoLimiteInferiorDim1 );
        this.tipoLimiteInferiorDim1 = tipoLimiteInferiorDim1;
    }

    public String getTipoLimiteSuperiorDim1() {
        return tipoLimiteSuperiorDim1;
    }

    public void setTipoLimiteSuperiorDim1(String tipoLimiteSuperiorDim1) {
        System.out.println("$%¨&$%¨&$%&$%& SETANDO TIPO LIMITE SUPERIOR DIM 1 PARA: " + tipoLimiteSuperiorDim1 );
        this.tipoLimiteSuperiorDim1 = tipoLimiteSuperiorDim1;
    }

    public String getTipoLimiteInferiorDim2() {
        return tipoLimiteInferiorDim2;
    }

    public void setTipoLimiteInferiorDim2(String tipoLimiteInferiorDim2) {
        System.out.println("$%¨&$%¨&$%&$%& SETANDO TIPO LIMITE INFERIOR DIM 2 PARA: " + tipoLimiteInferiorDim2 );
        this.tipoLimiteInferiorDim2 = tipoLimiteInferiorDim2;
    }

    public String getTipoLimiteSuperiorDim2() {
        return tipoLimiteSuperiorDim2;
    }

    public void setTipoLimiteSuperiorDim2(String tipoLimiteSuperiorDim2) {
        System.out.println("$%¨&$%¨&$%&$%& SETANDO TIPO LIMITE SUPERIOR DIM 2 PARA: " + tipoLimiteSuperiorDim2 );
        this.tipoLimiteSuperiorDim2 = tipoLimiteSuperiorDim2;
    }

    public int getValorInteiroInferiorDim1() {
        return valorInteiroInferiorDim1;
    }

    public void setValorInteiroInferiorDim1(int valorInteiroInferiorDim1) {
        System.out.println("$%¨&$%¨&$%&$%& SETANDO VALOR INTEIRO INFERIOR DIM 1: " + valorInteiroInferiorDim1 );
        this.valorInteiroInferiorDim1 = valorInteiroInferiorDim1;
    }

    public int getValorInteiroSuperiorDim1() {
        return valorInteiroSuperiorDim1;
    }

    public void setValorInteiroSuperiorDim1(int valorInteiroSuperiorDim1) {
        System.out.println("$%¨&$%¨&$%&$%& SETANDO VALOR INTEIRO SUPERIOR DIM 1: " + valorInteiroSuperiorDim1 );
        this.valorInteiroSuperiorDim1 = valorInteiroSuperiorDim1;
    }

    public int getValorInteiroInferiorDim2() {
        return valorInteiroInferiorDim2;
    }

    public void setValorInteiroInferiorDim2(int valorInteiroInferiorDim2) {
        System.out.println("$%¨&$%¨&$%&$%& SETANDO VALOR INTEIRO INFERIOR DIM 2" + valorInteiroInferiorDim2 );
        this.valorInteiroInferiorDim2 = valorInteiroInferiorDim2;
    }

    public int getValorInteiroSuperiorDim2() {
        return valorInteiroSuperiorDim2;
    }

    public void setValorInteiroSuperiorDim2(int valorInteiroSuperiorDim2) {
        System.out.println("$%¨&$%¨&$%&$%& SETANDO VALOR INTEIRO SUPERIOR DIM 2" + valorInteiroSuperiorDim2 );
        this.valorInteiroSuperiorDim2 = valorInteiroSuperiorDim2;
    }

    public String getValorCaracterInferiorDim1() {
        return valorCaracterInferiorDim1;
    }

    public void setValorCaracterInferiorDim1(String valorCaracterInferiorDim1) {
        System.out.println("$%¨&$%¨&$%&$%& setValorCaracterInferiorDim1: " + valorCaracterInferiorDim1 );
        this.valorCaracterInferiorDim1 = valorCaracterInferiorDim1;
    }

    public String getValorCaracterSuperiorDim1() {
        return valorCaracterSuperiorDim1;
    }

    public void setValorCaracterSuperiorDim1(String valorCaracterSuperiorDim1) {
        System.out.println("$%¨&$%¨&$%&$%& setValorCaracterSuperiorDim1: " + valorCaracterSuperiorDim1 );
        this.valorCaracterSuperiorDim1 = valorCaracterSuperiorDim1;
    }

    public String getValorCaracterInferiorDim2() {
        return valorCaracterInferiorDim2;
    }

    public void setValorCaracterInferiorDim2(String valorCaracterInferiorDim2) {
        System.out.println("$%¨&$%¨&$%&$%& setValorCaracterInferiorDim2: " + valorCaracterInferiorDim2 );
        this.valorCaracterInferiorDim2 = valorCaracterInferiorDim2;
    }

    public String getValorCaracterSuperiorDim2() {
        return valorCaracterSuperiorDim2;
    }

    public void setValorCaracterSuperiorDim2(String valorCaracterSuperiorDim2) {
        System.out.println("$%¨&$%¨&$%&$%& setValorCaracterSuperiorDim2: " + valorCaracterSuperiorDim2 );
        this.valorCaracterSuperiorDim2 = valorCaracterSuperiorDim2;
    }
    
    public int getNpf() {
        return npf;
    }

    public void setNpf(int npf) {
        System.out.println("&&&&&&&&&&&&&& MUDANDO O NPF PARA " + npf + "  &&&&&&&&&&&&&&&&&&");
        this.npf = npf;
    }
    
    public void incrementeNpf()
    {
        this.npf++;
        System.out.println("&&&&&&&&&&&&&& NPF INCREMENTADO PARA: " + this.npf + "  &&&&&&&&&&&&&&&&&&");
    }
    
    public void decrementeNpf()
    {
        this.npf--;
    }
    
    public String getMpp() {
        return mpp;
    }

    public void setMpp(String mpp) {
        System.out.println("&&&&&&&&&&&&&& MUDANDO O MPP PARA " + mpp + "  &&&&&&&&&&&&&&&&&&");
        this.mpp = mpp;
    }
    
    public int getNivelAtual() {
        return nivelAtual;
    }

    public void setNivelAtual(int nivelAtual) {
        this.nivelAtual = nivelAtual;
    }
    
    public void incrementaNivelAtual()
    {
        this.nivelAtual += 1;
    }
    
    public void decrementaNivelAtual()
    {
        this.nivelAtual -= 1;
    }
    
    public String getTipoAtual() {
        return tipoAtual;
    }

    public void setTipoAtual(String tipoAtual) {
        this.tipoAtual = tipoAtual;
    }

    public String getContextoLID() {
        return contextoLID;
    }

    public void setContextoLID(String contextoLID) {
        this.contextoLID = contextoLID;
    }
    

    public List<Simbolo> getTs() {
        return ts;
    }

    public void setTs(List<Simbolo> ts) {
        this.ts = ts;
    }
    
    public int getValorConstanteInteiro() {
        return valorConstanteInteiro;
    }

    public void setValorConstanteInteiro(int valorConstanteInteiro) {
        this.valorConstanteInteiro = valorConstanteInteiro;
    }

    public double getValorConstanteReal() {
        return valorConstanteReal;
    }

    public void setValorConstanteReal(double valorConstanteReal) {
        this.valorConstanteReal = valorConstanteReal;
        
        System.out.println( "$$$$$$$$$$$$$$$ this.valorConstanteReal: " + this.valorConstanteReal );
    }

    public boolean isValorConstanteBoolean() {
        return valorConstanteBoolean;
    }

    public void setValorConstanteBoolean(boolean valorConstanteBoolean) {
        this.valorConstanteBoolean = valorConstanteBoolean;
    }

    public String getValorConstanteLiteral() {
        return valorConstanteLiteral;
    }

    public void setValorConstanteLiteral(String valorConstanteLiteral) {
        this.valorConstanteLiteral = valorConstanteLiteral;
    }

    public void addSymbol(Simbolo s)
    {
        this.ts.add( s );
    }

    public boolean containsKey(String lexeme) {
        return true;
    }

    public void setaPrimeiroId(String lexeme) {
        this.primeiroIdLista = lexeme;
    }
    public String getPrimeiroId()
    {
        return this.primeiroIdLista;
    }
    
    public void setaUltimoId(String lexeme) {
        this.ultimoIdLista = lexeme;
    }
    public String getUltimoId()
    {
        return this.ultimoIdLista;
    }
    
    public void print()
    {
        System.out.println( "\u001B[31m----------- TABELA DE SÍMBOLOS -----------" );
        System.out.println( "\u001B[31m - NOME -    - CATEGORIA -     - Tipo da Constante -" );
        Iterator<Simbolo> it = this.ts.iterator();
        while( it.hasNext() )
        {
            Simbolo nex = (Simbolo) it.next();
            nex.print();
        }
        System.out.println( "\u001B[31m----------- FIM DA TABELA DE SÍMBOLOS -----------" );
        
    }

    public boolean verificaIdJaDeclarado(String lexeme)
    {
        boolean jaDeclarado = false;
        
        //verificar se este símbolo já foi declarado no nível atual
        Iterator<Simbolo> it = this.ts.iterator();
        while( it.hasNext() )
        {
            Simbolo next = it.next();
            
            this.escreva( "Símbolo da Iteração: " + next.getNome() + " " + next.getCategoria() );
            
            if( next.getNome().equalsIgnoreCase( lexeme ) && next.getNivelDeclarado() == this.nivelAtual )
            {
                jaDeclarado = true;
            }
        }
        
        return jaDeclarado;
    }
    
    public void escreva( String x )
    {
        System.out.println( x );
    }

    public void setTipoConstante(String tipo) {
        this.tipoConstante = tipo;
        
        this.escreva("Setando tipo constante para: " + this.tipoConstante);
    }
    
    public String getTipoConstante()
    {
        this.escreva("BUSCANDO TIPO DA CONSTANTE QUE É: " + this.tipoConstante);
        return this.tipoConstante;
    }

    /*
     * Retorna true se a categoria do lexeme for igual ao passado por parâmetro
     */
    public boolean comparaCategoriaId(String lexeme, String categoria)
    {
        boolean categoriasIguais = false;
        
        //buscar o símbolo
        Iterator<Simbolo> it = this.ts.iterator();
        while( it.hasNext() )
        {
            Simbolo next = it.next();
            if( next.getNome().equalsIgnoreCase( lexeme ) && next.getCategoria().equalsIgnoreCase( categoria ) )
            {
               categoriasIguais = true; 
            }
        }
        
        return categoriasIguais;        
    }

    /*
     * Atualizar a propriedade deste símbolo com o valor do atributo tipoConstante desta classe
     */
    public void setTipoConstanteParaId(String lexeme)
    {
        System.out.println( "@@@@@@@@@@@@@@ setTipoConstanteParaId @@@@@@@@@@@@" );
        
             
        //buscar o símbolo
        Iterator<Simbolo> it = this.ts.iterator();
        while( it.hasNext() )
        {
            Simbolo next = it.next();
            if( next.getNome().equalsIgnoreCase( lexeme ) && next.getNivelDeclarado() == this.nivelAtual )
            {
                //símbolo encontrado
                //atualizar o seu tipo constante
                System.out.println( "!!!!!!!!!!!!!!! TIPO: " + this.tipoConstante );
                next.setTipoConstante( this.tipoConstante );         
            }
        }
    }

    public void setValorConstanteParaId(String lexeme)
    {
        System.out.println( "!!!!!!!!!!!!!!! Entra no método SET VALOR CONSTATNTE !!!!!!!!!!!!!! " );
        
        //buscar o símbolo
        Iterator<Simbolo> it = this.ts.iterator();
        while( it.hasNext() )
        {
            Simbolo next = it.next();
            if( next.getNome().equalsIgnoreCase( lexeme ) && next.getNivelDeclarado() == this.nivelAtual )
            {
                //símbolo encontrado
                //atualizar o seu tipo constante
                switch( this.tipoConstante )
                {
                    case "inteiro":
                       next.setValorConstanteInteiro( this.valorConstanteInteiro );
                       break;
                    case "real":
                       next.setValorConstanteReal( this.valorConstanteReal );
                       break;
                    case "verdadeiro":
                    case "falso":
                       next.setValorConstanteBoolean( this.valorConstanteBoolean );
                       break;
                    case "literal":
                       next.setValorConstanteLiteral( this.valorConstanteLiteral ); 
                       break;
                }
                    
            }
        }
    }

    /*
     * Atualiza o tipo da variável para o tipoAtual
     */
    public void atualizaTipolId( String lexeme )
    {
        System.out.println( "******** ENTROU NO MÉTODO ATUALIZA TIPO VARIÁVEL ID *********" );
        System.out.println( "******** TIPO ATUAL: " + this.tipoAtual + " *********" );
        
        Iterator<Simbolo> it = this.ts.iterator();
        boolean encontrou = false;
        while( it.hasNext() && !encontrou )
        {
            Simbolo next = it.next();
            if( next.getNome().equalsIgnoreCase( lexeme ) )
            {
                //encontrou o id para fazer a atualização do seu tipo
                next.setTipoVariavel( this.tipoAtual );
            }
        }   
    }

    public void atualizaMppId(String lexeme)
    {
        System.out.println( "******** ENTROU NO MÉTODO ATUALIZA MPP DA ID *********" );
        System.out.println( "******** MPP ATUAL: " + this.mpp + " *********" );
        
        Iterator<Simbolo> it = this.ts.iterator();
        boolean encontrou = false;
        while( it.hasNext() && !encontrou )
        {
            Simbolo next = it.next();
            if( next.getNome().equalsIgnoreCase( lexeme ) )
            {
                //encontrou o id para fazer a atualização do seu tipo
                next.setMpp( this.mpp );
            }
        }
    }

    public void removaVariaveisDoNivelAtual()
    {
        Iterator<Simbolo> it = this.ts.iterator();
        while( it.hasNext() )
        {
            
            
            Simbolo next = it.next();
            if( next.getNivelDeclarado() == this.nivelAtual )
            {
                System.out.println( "\u001B[35mRemovendo símbolo do nível atual: " );
                next.print();
                        
                this.ts.remove(next);
            }
        }
    }

    public boolean verificaIdJaDeclaradoEmNivelAnterior(String lexeme)
    {
        boolean jaFoiDeclarado = false;
        
        Iterator<Simbolo> it = this.ts.iterator();
        while( it.hasNext() )
        {
            Simbolo next = it.next();
            if( next.getNome().equalsIgnoreCase( lexeme ) && next.getNivelDeclarado() < this.nivelAtual )
            {
                jaFoiDeclarado = true;
            }
        }
        
        return jaFoiDeclarado;
    }

    public boolean verificaIdDeclaradoEmNivelAnteriorComTipoAtual( String lexeme )
    {    
        //este médodo está sendo chamado um um contexto de par-formais onde a passagem de parâmetro é feita por referência
        //Deve-se verificar se existe um id declarado em um nível anterior ao nível atual com o mesmo nome e que tenha o mesmo tipo( inteiro, real, etc )
        //do tipoAtual
        boolean encontrouIgual = false;
        
        Iterator<Simbolo> it = this.ts.iterator();
        while( it.hasNext() )
        {
            Simbolo next = it.next();
            if( next.getNome().equalsIgnoreCase( lexeme ) && next.getNivelDeclarado() < this.nivelAtual && next.getTipoVariavel().equalsIgnoreCase( this.tipoAtual ) )
            {
                encontrouIgual = true;
            }
        }        

        return encontrouIgual;        
    }

    public void atualizeTipoRetornoDaFuncao( String funcao )
    {
        //atualizar o tipo de retorno da função que acabou de ser declarada
        Iterator<Simbolo> it = this.ts.iterator();
        while( it.hasNext() )
        {
            Simbolo next = it.next();
            //buscar o símbolo que representa a função e atualizar o seu tipo de retorno com o valor que tiver no atributo tipoAtual
            if( next.getNome().equalsIgnoreCase( funcao ))
            {
                //achei o símbolo que representa a função
                next.setTipoRetorno( this.tipoAtual );
            }
        }
        
        this.print();
    }

    public Simbolo getSimbolo( String lexeme )
    {
        Iterator<Simbolo> it = this.ts.iterator();
        while( it.hasNext() )
        {
            Simbolo next = it.next();
            if( next.getNome().equalsIgnoreCase( lexeme ) )
            {
                return next;

            }
        }
        return null;
    }

    /**
     * Atualizar informações que estão nos atributlos auxiliares referente a veter para o símbolo em questão
     * 
     * @param lexeme 
     */
    public void atualizaInfoVetor( String lexeme )
    {
        Iterator<Simbolo> it = this.ts.iterator();
        while( it.hasNext() )
        {
            Simbolo next = it.next();
            if( next.getNome().equalsIgnoreCase( lexeme ) )
            {
                System.out.println( "¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨&&&&&&&&&&&&&&@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"  );
                
                SimboloVariavelVetor vetor = new SimboloVariavelVetor( lexeme );
                
                vetor.setTipoVariavel( "vetor" );
                vetor.setTipoElementos( this.getTipoElementosVetor() );
                vetor.setnDimensoes( this.getNumeroDimensoesVetor() );
                
                vetor.setTipoLimiteInferiorDim1( this.tipoLimiteInferiorDim1 );
                if( this.tipoLimiteInferiorDim1.equalsIgnoreCase( "inteiro" ) )
                {
                    vetor.setValorInteiroInferiorDim1( this.valorInteiroInferiorDim1 );
                }
                else
                {
                    vetor.setValorCaracterInferiorDim1( this.valorCaracterInferiorDim1 );
                }
                vetor.setTipoLimiteSuperiorDim1( this.tipoLimiteSuperiorDim1 );
                if( this.tipoLimiteSuperiorDim1.equalsIgnoreCase( "inteiro" ) )
                {
                    vetor.setValorInteiroSuperiorDim1( this.valorInteiroSuperiorDim1 );
                }
                else
                {
                    vetor.setValorCaracterSuperiorDim1( this.valorCaracterSuperiorDim1 );
                }
                if( this.getNumeroDimensoesVetor() == 2 )
                {
                    //setar valores para a segunda dimensão
                    vetor.setTipoLimiteInferiorDim2( this.tipoLimiteInferiorDim2 );
                    if( this.tipoLimiteInferiorDim2.equalsIgnoreCase( "inteiro" ) )
                    {
                        vetor.setValorInteiroInferiorDim2( this.valorInteiroInferiorDim2 );
                    }
                    else
                    {
                        vetor.setValorCaracterInferiorDim2( this.valorCaracterInferiorDim2 );
                    }
                    vetor.setTipoLimiteSuperiorDim2( this.tipoLimiteSuperiorDim2 );
                    if( this.tipoLimiteSuperiorDim2.equalsIgnoreCase( "inteiro" ) )
                    {
                        vetor.setValorInteiroSuperiorDim2( this.valorInteiroSuperiorDim2 );
                    }
                    else
                    {
                        vetor.setValorCaracterSuperiorDim2( this.valorCaracterSuperiorDim2 );
                    }
                }
                
                this.ts.remove( next );
                this.addSymbol( vetor );
             
                vetor.print();
            }
        }
        
        
    }

    /**
     * Voltar para valores default os atributos auxiliares para vetor de forma que um outro vetor possa ser declarado com seus próprios atributos
     */
    public void limpeDadosAuxVetor()
    {
        //variáveis auxiliares para declaração de vetor
        this.tipoLimiteInferiorDim1 = "";
        this.tipoLimiteSuperiorDim1 = "";

        this.tipoLimiteInferiorDim2 = "";
        this.tipoLimiteSuperiorDim2 = "";

        this.valorInteiroInferiorDim1 = -1;
        this.valorInteiroSuperiorDim1 = -1;

        this.valorInteiroInferiorDim2 = -1;;
        this.valorInteiroSuperiorDim2 = -1;

        this.valorCaracterInferiorDim1 = "";
        this.valorCaracterSuperiorDim1 = "";

        this.valorCaracterInferiorDim2 = "";
        this.valorCaracterSuperiorDim2 = "";

        this.numeroDimensoesVetor = 0;
    }
}
